Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
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 shouldReturnWantedUrlWithoutArgsUsingPropertyAccess() throws Throwable { when(router.urlFor(TestController.class, anotherMethod, new Object[2])).thenReturn("/expectedURL"); String uri = invoke(handler.get(new DefaultBeanClass(TestController.class)), "getAnotherMethod"); assertThat(uri, is("/path/expectedURL")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldReturnWantedUrlWithParamArgs() throws Throwable { String a = "test"; int b = 3; when(router.urlFor(TestController.class, method2params, new Object[]{a, b})).thenReturn("/expectedURL"); String uri = invoke(handler.get(new DefaultBeanClass(TestController.class)), "method", a, b); assertThat(uri, is("/path/expectedURL")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldGetTypesCorrectlyOnInheritance() throws Exception { final Method method = new Mirror().on(AController.class).reflect().method("otherMethod").withArgs(BeanExtended.class); DefaultTypeFinder finder = new DefaultTypeFinder(provider, new DefaultReflectionProvider()); Map<String, Class<?>> types = finder.getParameterTypes(method, new String[] {"extended.id"}); assertEquals(Integer.class, types.get("extended.id")); }
@Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; }
DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } }
DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); }
DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); @Override Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths); }
DefaultTypeFinder implements TypeFinder { @Override public Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths) { Map<String,Class<?>> types = new HashMap<>(); Parameter[] parametersFor = provider.parametersFor(method); for (String path : parameterPaths) { for (Parameter parameter: parametersFor) { if (path.startsWith(parameter.getName() + ".") || path.equals(parameter.getName())) { String[] items = path.split("\\."); Class<?> type = parameter.getType(); for (int j = 1; j < items.length; j++) { String item = items[j]; try { type = reflectionProvider.getMethod(type, "get" + capitalize(item)).getReturnType(); } catch (Exception e) { throw new IllegalArgumentException("Parameters paths are invalid: " + Arrays.toString(parameterPaths) + " for method " + method, e); } } types.put(path, type); } } } return types; } protected DefaultTypeFinder(); @Inject DefaultTypeFinder(ParameterNameProvider provider, ReflectionProvider reflectionProvider); @Override Map<String, Class<?>> getParameterTypes(Method method, String[] parameterPaths); }
@Test public void shouldReturnWantedUrlWithPartialParamArgs() throws Throwable { String a = "test"; when(router.urlFor(TestController.class, anotherMethod, new Object[]{a, null})).thenReturn("/expectedUrl"); String uri = invoke(handler.get(new DefaultBeanClass(TestController.class)), "anotherMethod", a); assertThat(uri, is("/path/expectedUrl")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldReturnWantedUrlForOverrideMethodWithParamArgs() throws Throwable { String a = "test"; when(router.urlFor(SubGenericController.class, SubGenericController.class.getDeclaredMethod("method", new Class[]{String.class}), new Object[]{a})).thenReturn("/expectedURL"); String uri = invoke(handler.get(new DefaultBeanClass(SubGenericController.class)), "method", a); assertThat(uri, is("/path/expectedURL")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldReturnWantedUrlForOverrideMethodWithParialParamArgs() throws Throwable { String a = "test"; when(router.urlFor(SubGenericController.class, SubGenericController.class.getDeclaredMethod("anotherMethod", new Class[]{String.class, String.class}), new Object[]{a, null})).thenReturn("/expectedURL"); String uri = invoke(handler.get(new DefaultBeanClass(SubGenericController.class)), "anotherMethod", a); assertThat(uri, is("/path/expectedURL")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldUseExactlyMatchedMethodIfTheMethodIsOverloaded() throws Throwable { String a = "test"; when(router.urlFor(TestController.class, method1param, a)).thenReturn("/expectedUrl"); String uri = invoke(handler.get(new DefaultBeanClass(TestController.class)), "method", a); assertThat(uri, is("/path/expectedUrl")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldThrowExceptionWhenPassingMoreArgsThanMethodSupports() throws Throwable { String a = "test"; int b = 3; String c = "anotherTest"; try { invoke(handler.get(new DefaultBeanClass(TestController.class)), "anotherMethod", a, b, c); fail(); } catch (IllegalArgumentException e) { assertThat(e.getMessage().toLowerCase(), startsWith("wrong number of arguments")); } }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldAvoidFrozenClassIfTwoVRaptorInstancesAreLoaded() throws Throwable { ServletContext context0 = Mockito.mock(ServletContext.class); ServletContext context1 = Mockito.mock(ServletContext.class); when(context0.getContextPath()).thenReturn(""); when(context1.getContextPath()).thenReturn("/another"); ReflectionProvider reflectionProvider = new DefaultReflectionProvider(); Proxifier proxifier = new JavassistProxifier(); LinkToHandler handler0 = new LinkToHandler(context0, router, proxifier, reflectionProvider); LinkToHandler handler1 = new LinkToHandler(context1, router, proxifier, reflectionProvider); Object object0 = handler0.get(new DefaultBeanClass(TestController.class)); assertThat(object0.getClass().getName(), containsString("$linkTo_$$")); Object object1 = handler1.get(new DefaultBeanClass(TestController.class)); assertThat(object1.getClass().getName(), containsString("$linkTo$another_$$")); }
@Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
LinkToHandler extends ForwardingMap<Class<?>, Object> { @Override public Object get(Object key) { logger.debug("getting key {}", key); BeanClass beanClass = (BeanClass) key; final Class<?> controller = beanClass.getType(); Class<?> linkToInterface = interfaces.get(controller); if (linkToInterface == null) { logger.debug("interface not found, creating one {}", controller); lock.lock(); try { linkToInterface = interfaces.get(controller); if (linkToInterface == null) { String path = context.getContextPath().replace('/', '$'); String interfaceName = controller.getName() + "$linkTo" + path; linkToInterface = createLinkToInterface(controller, interfaceName); interfaces.put(controller, linkToInterface); logger.debug("created interface {} to {}", interfaceName, controller); } } finally { lock.unlock(); } } return proxifier.proxify(linkToInterface, new MethodInvocation<Object>() { @Override public Object intercept(Object proxy, Method method, Object[] args, SuperMethod superMethod) { String methodName = StringUtils.decapitalize(method.getName().replaceFirst("^get", "")); List<Object> params = args.length == 0 ? Collections.emptyList() : Arrays.asList(args); return linker(controller, methodName, params).getLink(); } }); } protected LinkToHandler(); @Inject LinkToHandler(ServletContext context, Router router, Proxifier proxifier, ReflectionProvider reflectionProvider); @PostConstruct void start(); @Override Object get(Object key); @PreDestroy void removeGeneratedClasses(); }
@Test public void shouldIncludeReturnValueOnForward() throws Exception { givenDispatcherWillBeReturnedWhenRequested(); when(extractor.nameFor(String.class)).thenReturn("string"); logicResult.forwardTo(MyComponent.class).returnsValue(); verify(dispatcher).forward(request, response); verify(request).setAttribute("string", "A value"); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldExecuteTheLogicAndRedirectToItsViewOnForward() throws Exception { final MyComponent component = givenDispatcherWillBeReturnedWhenRequested(); assertThat(component.calls, is(0)); logicResult.forwardTo(MyComponent.class).base(); assertThat(component.calls, is(1)); verify(dispatcher).forward(request, response); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldForwardToMethodsDefaultViewWhenResponseIsNotCommited() throws Exception { givenDispatcherWillBeReturnedWhenRequested(); when(response.isCommitted()).thenReturn(false); logicResult.forwardTo(MyComponent.class).base(); verify(dispatcher).forward(request, response); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldNotForwardToMethodsDefaultViewWhenResponseIsCommited() throws Exception { givenDispatcherWillBeReturnedWhenRequested(); when(response.isCommitted()).thenReturn(true); logicResult.forwardTo(MyComponent.class).base(); verify(dispatcher, never()).forward(request, response); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void canTranslate() { FixedMethodStrategy strategy = new FixedMethodStrategy("abc", list, methods(HttpMethod.POST), control, 0, new Parameter[0]); when(control.matches("/clients/add")).thenReturn(true); ControllerMethod match = strategy.controllerMethod(request, "/clients/add"); assertThat(match, is(VRaptorMatchers.controllerMethod(method("list")))); verify(control, only()).fillIntoRequest("/clients/add", request); }
@Override public ControllerMethod controllerMethod(MutableRequest request, String uri) { parameters.fillIntoRequest(uri, request); return this.controllerMethod; }
FixedMethodStrategy implements Route { @Override public ControllerMethod controllerMethod(MutableRequest request, String uri) { parameters.fillIntoRequest(uri, request); return this.controllerMethod; } }
FixedMethodStrategy implements Route { @Override public ControllerMethod controllerMethod(MutableRequest request, String uri) { parameters.fillIntoRequest(uri, request); return this.controllerMethod; } FixedMethodStrategy(String originalUri, ControllerMethod method, Set<HttpMethod> methods, ParametersControl control, int priority, Parameter[] parameterNames); }
FixedMethodStrategy implements Route { @Override public ControllerMethod controllerMethod(MutableRequest request, String uri) { parameters.fillIntoRequest(uri, request); return this.controllerMethod; } FixedMethodStrategy(String originalUri, ControllerMethod method, Set<HttpMethod> methods, ParametersControl control, int priority, Parameter[] parameterNames); @Override boolean canHandle(Class<?> type, Method method); @Override ControllerMethod controllerMethod(MutableRequest request, String uri); @Override EnumSet<HttpMethod> allowedMethods(); @Override boolean canHandle(String uri); @Override String urlFor(Class<?> type, Method m, Object... params); @Override int getPriority(); @Override String getOriginalUri(); @Override ControllerMethod getControllerMethod(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
FixedMethodStrategy implements Route { @Override public ControllerMethod controllerMethod(MutableRequest request, String uri) { parameters.fillIntoRequest(uri, request); return this.controllerMethod; } FixedMethodStrategy(String originalUri, ControllerMethod method, Set<HttpMethod> methods, ParametersControl control, int priority, Parameter[] parameterNames); @Override boolean canHandle(Class<?> type, Method method); @Override ControllerMethod controllerMethod(MutableRequest request, String uri); @Override EnumSet<HttpMethod> allowedMethods(); @Override boolean canHandle(String uri); @Override String urlFor(Class<?> type, Method m, Object... params); @Override int getPriority(); @Override String getOriginalUri(); @Override ControllerMethod getControllerMethod(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }
@Test public void shouldPutParametersOnFlashScopeOnRedirect() throws Exception { logicResult.redirectTo(MyComponent.class).withParameter("a"); verify(flash).includeParameters(any(ControllerMethod.class), eq(new Object[] {"a"})); }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldNotPutParametersOnFlashScopeOnRedirectIfThereAreNoParameters() throws Exception { logicResult.redirectTo(MyComponent.class).base(); verify(flash, never()).includeParameters(any(ControllerMethod.class), any(Object[].class)); }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void clientRedirectingWillRedirectToTranslatedUrl() throws NoSuchMethodException, IOException { final String url = "custom_url"; when(request.getContextPath()).thenReturn("/context"); when(router.urlFor(MyComponent.class, MyComponent.class.getDeclaredMethod("base"))).thenReturn(url); logicResult.redirectTo(MyComponent.class).base(); verify(response).sendRedirect("/context" + url); }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void canRedirectWhenLogicMethodIsNotAnnotatedWithHttpMethods() throws Exception { logicResult.redirectTo(MyComponent.class).base(); verify(response).sendRedirect(any(String.class)); }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void canRedirectWhenLogicMethodIsAnnotatedWithHttpGetMethod() throws Exception { logicResult.redirectTo(MyComponent.class).annotatedWithGet(); verify(response).sendRedirect(any(String.class)); }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void cannotRedirectWhenLogicMethodIsAnnotatedWithAnyHttpMethodButGet() throws Exception { try { logicResult.redirectTo(MyComponent.class).annotated(); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException e) { verify(response, never()).sendRedirect(any(String.class)); } }
@Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T redirectTo(final Class<T> type) { logger.debug("redirecting to class {}", type.getSimpleName()); return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { checkArgument(acceptsHttpGet(method), "Your logic method must accept HTTP GET method if you want to redirect to it"); try { String url = router.urlFor(type, method, args); String path = request.getContextPath() + url; includeParametersInFlash(type, method, args); logger.debug("redirecting to {}", path); response.sendRedirect(path); return null; } catch (IOException e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldNotWrapValidationExceptionWhenForwarding() throws Exception { exception.expect(ValidationException.class); givenDispatcherWillBeReturnedWhenRequested(); when(response.isCommitted()).thenReturn(true); logicResult.forwardTo(MyComponent.class).throwsValidationException(); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldForwardToTheRightDefaultValue() throws Exception { Result result = mock(Result.class); PageResult pageResult = new DefaultPageResult(request, response, methodInfo, resolver, proxifier); when(result.use(PageResult.class)).thenReturn(pageResult); when(container.instanceFor(TheComponent.class)).thenReturn(new TheComponent(result)); when(resolver.pathFor(argThat(sameMethodAs(TheComponent.class.getDeclaredMethod("method"))))).thenReturn("controlled!"); when(request.getRequestDispatcher(anyString())).thenThrow(new AssertionError("should have called with the right method!")); doReturn(dispatcher).when(request).getRequestDispatcher("controlled!"); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(MyComponent.class, MyComponent.class.getDeclaredMethod("base"))); logicResult.forwardTo(TheComponent.class).method(); }
@Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
DefaultLogicResult implements LogicResult { @Override public <T> T forwardTo(final Class<T> type) { return proxifier.proxify(type, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { logger.debug("Executing {}", method); ControllerMethod old = methodInfo.getControllerMethod(); methodInfo.setControllerMethod(DefaultControllerMethod.instanceFor(type, method)); Object methodResult = method.invoke(container.instanceFor(type), args); methodInfo.setControllerMethod(old); Type returnType = method.getGenericReturnType(); if (!(returnType == void.class)) { request.setAttribute(extractor.nameFor(returnType), methodResult); } if (response.isCommitted()) { logger.debug("Response already commited, not forwarding."); return null; } String path = resolver.pathFor(DefaultControllerMethod.instanceFor(type, method)); logger.debug("Forwarding to {}", path); request.getRequestDispatcher(path).forward(request, response); return null; } catch (InvocationTargetException e) { propagateIfPossible(e.getCause()); throw new ProxyInvocationException(e); } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultLogicResult(); @Inject DefaultLogicResult(Proxifier proxifier, Router router, MutableRequest request, HttpServletResponse response, Container container, PathResolver resolver, TypeNameExtractor extractor, FlashScope flash, MethodInfo methodInfo); @Override T forwardTo(final Class<T> type); @Override T redirectTo(final Class<T> type); }
@Test public void shouldComplainIfThereIsNothingRegistered() { Assert.assertEquals("unknown", mimeTypeToFormat.getFormat("unknown")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void shouldReturnHtmlWhenRequestingAnyContentType() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("*/*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void addsAPrefixToMethodsWhenTheControllerHasMoreThanOneAnnotatedPath() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("You must specify exactly one path on @Path at class " + MoreThanOnePathAnnotatedController.class.getName()); parser.rulesFor(new DefaultBeanClass(MoreThanOnePathAnnotatedController.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 shouldReturnHtmlWhenAcceptsIsBlankContentType() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void shouldReturnHtmlWhenRequestingUnknownAsFirstAndAnyContentType() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("unknow, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testHtml() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("text/html")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testJson() { Assert.assertEquals("json", mimeTypeToFormat.getFormat("application/json")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testJsonWithQualifier() { Assert.assertEquals("json", mimeTypeToFormat.getFormat("application/json; q=0.4")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testNull() { Assert.assertEquals("html", mimeTypeToFormat.getFormat(null)); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testJsonInAComplexAcceptHeader() { Assert.assertEquals("json", mimeTypeToFormat.getFormat("application/json, text/javascript, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testPrecendenceInAComplexAcceptHeaderHtmlShouldPrevailWhenTied() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("application/json, text/html, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testPrecendenceInABizzarreMSIE8AcceptHeader() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testPrecendenceInABizzarreMSIE8AcceptHeaderWithHtml() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, text/html, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithRelativePath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(PathAnnotatedController.class)); Route route = getRouteMatching(routes, "/prefix/relativePath"); assertThat(route, canHandle(PathAnnotatedController.class, "withRelativePath")); }
@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 testPrecendenceInAComplexAcceptHeaderHtmlShouldPrevailWhenTied2() { Assert.assertEquals("html", mimeTypeToFormat.getFormat("text/html, application/json, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testJsonInAComplexAcceptHeaderWithParameters() { Assert.assertEquals("json", mimeTypeToFormat.getFormat("application/json; q=0.7, application/xml; q=0.1, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void testXMLInAComplexAcceptHeaderWithParametersNotOrdered() { Assert.assertEquals("xml", mimeTypeToFormat.getFormat("application/json; q=0.1, application/xml; q=0.7, */*")); }
@Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
DefaultAcceptHeaderToFormat implements AcceptHeaderToFormat { @Override public String getFormat(final String acceptHeader) { if (acceptHeader == null || acceptHeader.trim().equals("")) { return DEFAULT_FORMAT; } if (acceptHeader.contains(DEFAULT_FORMAT)) { return DEFAULT_FORMAT; } return acceptToFormatCache.fetch(acceptHeader, new Supplier<String>() { @Override public String get() { return chooseMimeType(acceptHeader); } }); } protected DefaultAcceptHeaderToFormat(); @Inject DefaultAcceptHeaderToFormat(@LRU CacheStore<String, String> acceptToFormatCache); @Override String getFormat(final String acceptHeader); }
@Test public void shouldUseValidationVersionOfLogicResult() throws Exception { exception.expect(ValidationException.class); when(result.use(LogicResult.class)).thenReturn(new MockedLogic()); factory.instanceFor(LogicResult.class, errors).forwardTo(RandomComponent.class).random(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void shouldThrowExceptionOnlyAtTheEndOfValidationCall() throws Exception { when(result.use(LogicResult.class)).thenReturn(new MockedLogic()); when(result.use(PageResult.class)).thenReturn(new MockedPage()); factory.instanceFor(LogicResult.class, errors); factory.instanceFor(LogicResult.class, errors).forwardTo(RandomComponent.class); factory.instanceFor(PageResult.class, errors); factory.instanceFor(PageResult.class, errors).of(RandomComponent.class); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void shouldUseValidationVersionOfPageResult() throws Exception { exception.expect(ValidationException.class); when(result.use(PageResult.class)).thenReturn(new MockedPage()); factory.instanceFor(PageResult.class, errors).forwardTo("any uri"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void shouldUseValidationVersionOfEmptyResult() throws Exception { exception.expect(ValidationException.class); when(result.use(EmptyResult.class)).thenReturn(new EmptyResult()); factory.instanceFor(EmptyResult.class, errors); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onHttpResultShouldNotThrowExceptionsOnHeaders() throws Exception { HttpResult httpResult = mock(HttpResult.class); when(result.use(HttpResult.class)).thenReturn(httpResult); factory.instanceFor(HttpResult.class, errors); factory.instanceFor(HttpResult.class, errors).addDateHeader("abc", 123l); factory.instanceFor(HttpResult.class, errors).addHeader("def", "ghi"); factory.instanceFor(HttpResult.class, errors).addIntHeader("jkl", 456); factory.instanceFor(HttpResult.class, errors).addIntHeader("jkl", 456); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onHttpResultShouldThrowExceptionsOnSendError() throws Exception { exception.expect(ValidationException.class); HttpResult httpResult = mock(HttpResult.class); when(result.use(HttpResult.class)).thenReturn(httpResult); factory.instanceFor(HttpResult.class, errors).sendError(404); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onHttpResultShouldThrowExceptionsOnSendErrorWithMessage() throws Exception { exception.expect(ValidationException.class); HttpResult httpResult = mock(HttpResult.class); when(result.use(HttpResult.class)).thenReturn(httpResult); factory.instanceFor(HttpResult.class, errors).sendError(404, "Not Found"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithRelativePath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(EndSlashAnnotatedController.class)); Route route = getRouteMatching(routes, "/endSlash/relativePath"); assertThat(route, canHandle(EndSlashAnnotatedController.class, "withRelativePath")); }
@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 onHttpResultShouldThrowExceptionsOnSetStatus() throws Exception { exception.expect(ValidationException.class); HttpResult httpResult = mock(HttpResult.class); when(result.use(HttpResult.class)).thenReturn(httpResult); factory.instanceFor(HttpResult.class, errors).setStatusCode(200); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void shouldBeAbleToChainMethodsOnHttpResult() throws Exception { HttpResult httpResult = mock(HttpResult.class); when(result.use(HttpResult.class)).thenReturn(httpResult); factory.instanceFor(HttpResult.class, errors).addDateHeader("abc", 123l).addHeader("def", "ghi").addIntHeader("jkl", 234); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnMoved() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); when(status.movedPermanentlyTo(RandomComponent.class)).thenReturn(new RandomComponent()); try { factory.instanceFor(Status.class, errors).movedPermanentlyTo(RandomComponent.class); } catch (ValidationException e) { Assert.fail("The exception must occur only on method call"); } factory.instanceFor(Status.class, errors).movedPermanentlyTo(RandomComponent.class).random(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnMovedToLogic() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).movedPermanentlyTo("anywhere"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onRefererResultShouldThrowExceptionsOnForward() throws Exception { exception.expect(ValidationException.class); RefererResult referer = mock(RefererResult.class); when(result.use(RefererResult.class)).thenReturn(referer); factory.instanceFor(RefererResult.class, errors).forward(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onRefererResultShouldThrowExceptionsOnRedirect() throws Exception { exception.expect(ValidationException.class); RefererResult referer = mock(RefererResult.class); when(result.use(RefererResult.class)).thenReturn(referer); factory.instanceFor(RefererResult.class, errors).redirect(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnNotFound() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).notFound(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnHeader() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).header("abc", "def"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnCreated() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).created(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnCreatedWithLocation() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).created("/newLocation"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(EndSlashAnnotatedController.class)); Route route = getRouteMatching(routes, "/endSlash/absolutePath"); assertThat(route, canHandle(EndSlashAnnotatedController.class, "withAbsolutePath")); }
@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 onStatusResultShouldThrowExceptionsOnOk() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).ok(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnConflict() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).conflict(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnMethodNotAllowed() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).methodNotAllowed(EnumSet.allOf(HttpMethod.class)); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnMovedPermanentlyTo() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); factory.instanceFor(Status.class, errors).movedPermanentlyTo("/newUri"); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onStatusResultShouldThrowExceptionsOnMovedPermanentlyToLogic() throws Exception { exception.expect(ValidationException.class); Status status = mock(Status.class); when(result.use(Status.class)).thenReturn(status); when(status.movedPermanentlyTo(RandomComponent.class)).thenReturn(new RandomComponent()); try { factory.instanceFor(Status.class, errors).movedPermanentlyTo(RandomComponent.class); } catch (ValidationException e) { Assert.fail("Should not throw exception yet"); } factory.instanceFor(Status.class, errors).movedPermanentlyTo(RandomComponent.class).random(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onXMLSerializationResultShouldThrowExceptionOnlyOnSerializeMethod() throws Exception { exception.expect(ValidationException.class); JSONSerialization serialization = mock(JSONSerialization.class); serializerBuilder = mock(SerializerBuilder.class, new Answer<SerializerBuilder>() { @Override public SerializerBuilder answer(InvocationOnMock invocation) throws Throwable { return serializerBuilder; } }); when(result.use(JSONSerialization.class)).thenReturn(serialization); when(serialization.from(any())).thenReturn(serializerBuilder); try { factory.instanceFor(JSONSerialization.class, errors).from(new Object()); factory.instanceFor(JSONSerialization.class, errors).from(new Object()).include("abc"); factory.instanceFor(JSONSerialization.class, errors).from(new Object()).exclude("abc"); } catch (ValidationException e) { Assert.fail("Should not throw exception yet"); } factory.instanceFor(JSONSerialization.class, errors).from(new Object()).serialize(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void onSerializerResultsShouldBeAbleToCreateValidationInstancesEvenIfChildClassesUsesCovariantType() throws Exception { exception.expect(ValidationException.class); JSONSerialization serialization = mock(JSONSerialization.class); serializerBuilder = new RandomSerializer(); when(result.use(JSONSerialization.class)).thenReturn(serialization); when(serialization.from(any())).thenReturn(serializerBuilder); try { factory.instanceFor(JSONSerialization.class, errors).from(new Object()); factory.instanceFor(JSONSerialization.class, errors).from(new Object()).include("abc"); factory.instanceFor(JSONSerialization.class, errors).from(new Object()).exclude("abc"); } catch (ValidationException e) { Assert.fail("Should not throw exception yet"); } factory.instanceFor(JSONSerialization.class, errors).from(new Object()).serialize(); }
@Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
DefaultValidationViewsFactory implements ValidationViewsFactory { @Override public <T extends View> T instanceFor(final Class<T> view, final List<Message> errors) { if (view.equals(EmptyResult.class)) { throw new ValidationException(errors); } return proxifier.proxify(view, throwValidationErrorOnFinalMethods(view, errors, result.use(view))); } protected DefaultValidationViewsFactory(); @Inject DefaultValidationViewsFactory(Result result, Proxifier proxifier, ReflectionProvider reflectionProvider); @Override T instanceFor(final Class<T> view, final List<Message> errors); }
@Test public void shouldSetHeader() throws Exception { status.header("Content-type", "application/xml"); verify(response).addHeader("Content-type", "application/xml"); }
@Override public void header(String key, String value) { response.addHeader(key, value); }
DefaultStatus implements Status { @Override public void header(String key, String value) { response.addHeader(key, value); } }
DefaultStatus implements Status { @Override public void header(String key, String value) { response.addHeader(key, value); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void header(String key, String value) { response.addHeader(key, value); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void header(String key, String value) { response.addHeader(key, value); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetCreatedStatus() throws Exception { status.created(); verify(response).setStatus(201); }
@Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetCreatedStatusAndLocationWithAppPath() throws Exception { when(config.getApplicationPath()).thenReturn("http: status.created("/newResource"); verify(response).setStatus(201); verify(response).addHeader("Location", "http: }
@Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void created() { response.setStatus(HttpServletResponse.SC_CREATED); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithEmptyPath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(EndSlashAnnotatedController.class)); Route route = getRouteMatching(routes, "/endSlash/"); assertThat(route, canHandle(EndSlashAnnotatedController.class, "withEmptyPath")); }
@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 shouldSetOkStatus() throws Exception { status.ok(); verify(response).setStatus(200); }
@Override public void ok() { response.setStatus(HttpServletResponse.SC_OK); result.use(Results.nothing()); }
DefaultStatus implements Status { @Override public void ok() { response.setStatus(HttpServletResponse.SC_OK); result.use(Results.nothing()); } }
DefaultStatus implements Status { @Override public void ok() { response.setStatus(HttpServletResponse.SC_OK); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void ok() { response.setStatus(HttpServletResponse.SC_OK); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void ok() { response.setStatus(HttpServletResponse.SC_OK); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetAcceptedStatus() throws Exception { status.accepted(); verify(response).setStatus(202); }
@Override public void accepted(){ response.setStatus(HttpServletResponse.SC_ACCEPTED ); result.use(Results.nothing()); }
DefaultStatus implements Status { @Override public void accepted(){ response.setStatus(HttpServletResponse.SC_ACCEPTED ); result.use(Results.nothing()); } }
DefaultStatus implements Status { @Override public void accepted(){ response.setStatus(HttpServletResponse.SC_ACCEPTED ); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void accepted(){ response.setStatus(HttpServletResponse.SC_ACCEPTED ); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void accepted(){ response.setStatus(HttpServletResponse.SC_ACCEPTED ); result.use(Results.nothing()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetNotImplementedStatus() throws Exception { status.notImplemented(); verify(response).setStatus(501); }
@Override public void notImplemented() { response.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED); }
DefaultStatus implements Status { @Override public void notImplemented() { response.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED); } }
DefaultStatus implements Status { @Override public void notImplemented() { response.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void notImplemented() { response.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void notImplemented() { response.setStatus(HttpServletResponse.SC_NOT_IMPLEMENTED); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetInternalServerErrorStatus() throws Exception { status.internalServerError(); verify(response).setStatus(500); }
@Override public void internalServerError() { response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); }
DefaultStatus implements Status { @Override public void internalServerError() { response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } }
DefaultStatus implements Status { @Override public void internalServerError() { response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void internalServerError() { response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void internalServerError() { response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetMovedPermanentlyStatus() throws Exception { when(config.getApplicationPath()).thenReturn("http: status.movedPermanentlyTo("/newURL"); verify(response).setStatus(301); verify(response).addHeader("Location", "http: }
@Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldMoveToExactlyURIWhenItIsNotAbsolute() throws Exception { status.movedPermanentlyTo("http: verify(response).addHeader("Location", "http: verify(response).setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); }
@Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldSetMovedPermanentlyStatusOfLogic() throws Exception { when(config.getApplicationPath()).thenReturn("http: Method method = Resource.class.getDeclaredMethod("method"); when(router.urlFor(eq(Resource.class), eq(method), Mockito.anyVararg())).thenReturn("/resource/method"); status.movedPermanentlyTo(Resource.class).method(); verify(response).setStatus(301); verify(response).addHeader("Location", "http: }
@Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void movedPermanentlyTo(String location) { this.response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); header("Location", fixLocation(location)); this.response.addIntHeader("Content-length", 0); this.response.addDateHeader("Date", System.currentTimeMillis()); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@SuppressWarnings("deprecation") @Test public void shouldSerializeErrorMessages() throws Exception { Message normal = new SimpleMessage("category", "The message"); I18nMessage i18ned = new I18nMessage("category", "message"); i18ned.setBundle(new SingletonResourceBundle("message", "Something else")); XStreamBuilder xstreamBuilder = cleanInstance(new MessageConverter()); MockSerializationResult result = new MockSerializationResult(null, xstreamBuilder, null, null); DefaultStatus status = new DefaultStatus(response, result, config, new JavassistProxifier(), router); status.badRequest(Arrays.asList(normal, i18ned)); String serialized = result.serializedResult(); assertThat(serialized, containsString("<message>The message</message>")); assertThat(serialized, containsString("<category>category</category>")); assertThat(serialized, containsString("<message>Something else</message>")); assertThat(serialized, not(containsString("<validationMessage>"))); assertThat(serialized, not(containsString("<i18nMessage>"))); }
@Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@SuppressWarnings("deprecation") @Test public void shouldSerializeErrorMessagesInJSON() throws Exception { Message normal = new SimpleMessage("category", "The message"); I18nMessage i18ned = new I18nMessage("category", "message"); i18ned.setBundle(new SingletonResourceBundle("message", "Something else")); List<JsonSerializer<?>> gsonSerializers = new ArrayList<>(); List<JsonDeserializer<?>> gsonDeserializers = new ArrayList<>(); gsonSerializers.add(new MessageGsonConverter()); GsonSerializerBuilder gsonBuilder = new GsonBuilderWrapper(new MockInstanceImpl<>(gsonSerializers), new MockInstanceImpl<>(gsonDeserializers), new Serializee(new DefaultReflectionProvider()), new DefaultReflectionProvider()); MockSerializationResult result = new MockSerializationResult(null, null, gsonBuilder, new DefaultReflectionProvider()) { @Override public <T extends View> T use(Class<T> view) { return view.cast(new DefaultRepresentationResult(new FormatResolver() { @Override public String getAcceptFormat() { return "json"; } }, this, new MockInstanceImpl<Serialization>(super.use(JSONSerialization.class)))); } }; DefaultStatus status = new DefaultStatus(response, result, config, new JavassistProxifier(), router); status.badRequest(Arrays.asList(normal, i18ned)); String serialized = result.serializedResult(); assertThat(serialized, containsString("\"message\":\"The message\"")); assertThat(serialized, containsString("\"category\":\"category\"")); assertThat(serialized, containsString("\"message\":\"Something else\"")); assertThat(serialized, not(containsString("\"validationMessage\""))); assertThat(serialized, not(containsString("\"i18nMessage\""))); }
@Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
DefaultStatus implements Status { @Override public void badRequest(String message) { sendError(HttpServletResponse.SC_BAD_REQUEST, message); } protected DefaultStatus(); @Inject DefaultStatus(HttpServletResponse response, Result result, Configuration config, Proxifier proxifier, Router router); @Override void notFound(); @Override void header(String key, String value); @Override void created(); @Override void created(String location); @Override void ok(); @Override void conflict(); @Override void methodNotAllowed(EnumSet<HttpMethod> allowedMethods); @Override void movedPermanentlyTo(String location); @Override T movedPermanentlyTo(final Class<T> controller); @Override void unsupportedMediaType(String message); @Override void badRequest(String message); @Override void badRequest(List<?> errors); @Override void forbidden(String message); @Override void noContent(); @Override void notAcceptable(); @Override void accepted(); @Override void notModified(); @Override void notImplemented(); @Override void internalServerError(); }
@Test public void shouldRedirectIncludingContext() throws Exception { when(request.getContextPath()).thenReturn("/context"); view.redirectTo("/any/url"); verify(response).sendRedirect("/context/any/url"); }
@Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(PathAnnotatedController.class)); Route route = getRouteMatching(routes, "/prefix/absolutePath"); assertThat(route, canHandle(PathAnnotatedController.class, "withAbsolutePath")); }
@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 searchesOnTheFallbackRequest() { assertThat(vraptor.getParameter("name"), is(equalTo("guilherme"))); }
@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 shouldNotIncludeContextPathIfURIIsAbsolute() throws Exception { view.redirectTo("http: verify(request, never()).getContextPath(); verify(response, only()).sendRedirect("http: }
@Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowResultExceptionIfIOExceptionOccursWhileRedirect() throws Exception { exception.expect(ResultException.class); doThrow(new IOException()).when(response).sendRedirect(anyString()); view.redirectTo("/any/url"); }
@Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void redirectTo(String url) { logger.debug("redirection to {}", url); try { if (url.startsWith("/")) { response.sendRedirect(request.getContextPath() + url); } else { response.sendRedirect(url); } } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldForwardToGivenURI() throws Exception { when(request.getRequestDispatcher("/any/url")).thenReturn(dispatcher); view.forwardTo("/any/url"); verify(dispatcher, only()).forward(request, response); }
@Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowResultExceptionIfServletExceptionOccursWhileForwarding() throws Exception { exception.expect(ResultException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new ServletException()).when(dispatcher).forward(request, response); view.forwardTo("/any/url"); }
@Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowResultExceptionIfIOExceptionOccursWhileForwarding() throws Exception { exception.expect(ResultException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new IOException()).when(dispatcher).forward(request, response); view.forwardTo("/any/url"); }
@Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void forwardTo(String url) { logger.debug("forwarding to {}", url); try { request.getRequestDispatcher(url).forward(request, response); } catch (ServletException | IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldAllowCustomPathResolverWhileForwardingView() throws ServletException, IOException { when(request.getRequestDispatcher("fixed")).thenReturn(dispatcher); view.defaultView(); verify(dispatcher, only()).forward(request, response); }
@Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowApplicationLogicExceptionIfServletExceptionOccursWhileForwardingView() throws Exception { exception.expect(ApplicationLogicException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new ServletException()).when(dispatcher).forward(request, response); view.defaultView(); }
@Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowResultExceptionIfIOExceptionOccursWhileForwardingView() throws Exception { exception.expect(ResultException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new IOException()).when(dispatcher).forward(request, response); view.defaultView(); }
@Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void defaultView() { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("forwarding to {}", to); try { request.getRequestDispatcher(to).forward(request, response); } catch (ServletException e) { throw new ApplicationLogicException(to + " raised an exception", e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldAllowCustomPathResolverWhileIncluding() throws ServletException, IOException { when(request.getRequestDispatcher("fixed")).thenReturn(dispatcher); view.include(); verify(dispatcher, only()).include(request, response); }
@Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldThrowResultExceptionIfServletExceptionOccursWhileIncluding() throws Exception { exception.expect(ResultException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new ServletException()).when(dispatcher).include(request, response); view.include(); }
@Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithEmptyPath() throws Exception { List<Route> routes = parser.rulesFor(new DefaultBeanClass(PathAnnotatedController.class)); Route route = getRouteMatching(routes, "/prefix"); assertThat(route, canHandle(PathAnnotatedController.class, "withEmptyPath")); }
@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 shouldThrowResultExceptionIfIOExceptionOccursWhileIncluding() throws Exception { exception.expect(ResultException.class); when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); doThrow(new IOException()).when(dispatcher).include(request, response); view.include(); }
@Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public void include() { try { String to = resolver.pathFor(methodInfo.getControllerMethod()); logger.debug("including {}", to); request.getRequestDispatcher(to).include(request, response); } catch (ServletException e) { throw new ResultException(e); } catch (IOException e) { throw new ResultException(e); } } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shoudNotExecuteLogicWhenUsingResultOf() { when(request.getRequestDispatcher(anyString())).thenReturn(dispatcher); try { view.of(SimpleController.class).notAllowedMethod(); } catch (UnsupportedOperationException e) { fail("Method should not be executed"); } }
@Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shoudThrowProxyInvocationExceptionIfAndExceptionOccursWhenUsingResultOf() { exception.expect(ProxyInvocationException.class); doThrow(new NullPointerException()).when(request).getRequestDispatcher(anyString()); view.of(SimpleController.class).notAllowedMethod(); }
@Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
DefaultPageResult implements PageResult { @Override public <T> T of(final Class<T> controllerType) { return proxifier.proxify(controllerType, new MethodInvocation<T>() { @Override public Object intercept(T proxy, Method method, Object[] args, SuperMethod superMethod) { try { request.getRequestDispatcher( resolver.pathFor(DefaultControllerMethod.instanceFor(controllerType, method))).forward( request, response); return null; } catch (Exception e) { throw new ProxyInvocationException(e); } } }); } protected DefaultPageResult(); @Inject DefaultPageResult(MutableRequest req, MutableResponse res, MethodInfo methodInfo, PathResolver resolver, Proxifier proxifier); @Override void defaultView(); @Override void include(); @Override void redirectTo(String url); @Override void forwardTo(String url); @Override T of(final Class<T> controllerType); }
@Test public void shouldUseResourceTypeAndMethodNameToResolveJsp(){ when(formatResolver.getAcceptFormat()).thenReturn(null); String result = resolver.pathFor(method); assertThat(result, is("/WEB-INF/jsp/dog/bark.jsp")); }
@Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
@Test public void shouldUseTheFormatIfSupplied() throws NoSuchMethodException { when(formatResolver.getAcceptFormat()).thenReturn("json"); String result = resolver.pathFor(method); assertThat(result, is("/WEB-INF/jsp/dog/bark.json.jsp")); }
@Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
@Test public void shouldIgnoreHtmlFormat() throws NoSuchMethodException { when(formatResolver.getAcceptFormat()).thenReturn("html"); String result = resolver.pathFor(method); assertThat(result, is("/WEB-INF/jsp/dog/bark.jsp")); }
@Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
DefaultPathResolver implements PathResolver { @Override public String pathFor(ControllerMethod method) { logger.debug("Resolving path for {}", method); String format = resolver.getAcceptFormat(); String suffix = ""; if (format != null && !format.equals("html")) { suffix = "." + format; } String name = method.getController().getType().getSimpleName(); String folderName = extractControllerFromName(name); String path = getPrefix() + folderName + "/" + method.getMethod().getName() + suffix + "." + getExtension(); logger.debug("Returning path {} for {}", path, method); return path; } protected DefaultPathResolver(); @Inject DefaultPathResolver(FormatResolver resolver); @Override String pathFor(ControllerMethod method); }
@Test public void shouldSendError() throws Exception { httpResult.sendError(SC_INTERNAL_SERVER_ERROR); verify(response).sendError(SC_INTERNAL_SERVER_ERROR); }
@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 shouldThrowsResultExceptionIfAnIOExceptionWhenSendError() throws Exception { doThrow(new IOException()).when(response).sendError(anyInt()); try { httpResult.sendError(SC_INTERNAL_SERVER_ERROR); fail("should throw ResultException"); } catch (ResultException e) { verify(response, only()).sendError(anyInt()); } }
@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); }