/***
* Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package br.com.caelum.vraptor.http.route;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.when;
import java.util.EnumSet;
import java.util.List;
import javax.annotation.Resource;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import br.com.caelum.vraptor.Delete;
import br.com.caelum.vraptor.Get;
import br.com.caelum.vraptor.Head;
import br.com.caelum.vraptor.Options;
import br.com.caelum.vraptor.Patch;
import br.com.caelum.vraptor.Path;
import br.com.caelum.vraptor.Post;
import br.com.caelum.vraptor.core.Converters;
import br.com.caelum.vraptor.http.ParameterNameProvider;
import br.com.caelum.vraptor.proxy.JavassistProxifier;
import br.com.caelum.vraptor.proxy.ObjenesisInstanceCreator;
import br.com.caelum.vraptor.proxy.Proxifier;
import br.com.caelum.vraptor.resource.DefaultResourceClass;
import br.com.caelum.vraptor.resource.HttpMethod;
public class PathAnnotationRoutesParserTest {
private Proxifier proxifier;
private @Mock Converters converters;
private NoTypeFinder typeFinder;
private @Mock Router router;
private @Mock ParameterNameProvider nameProvider;
private PathAnnotationRoutesParser parser;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
this.proxifier = new JavassistProxifier(new ObjenesisInstanceCreator());
this.typeFinder = new NoTypeFinder();
when(router.builderFor(anyString())).thenAnswer(new Answer<DefaultRouteBuilder>() {
public DefaultRouteBuilder answer(InvocationOnMock invocation) throws Throwable {
return new DefaultRouteBuilder(proxifier, typeFinder, converters, nameProvider, new JavaEvaluator(), (String) invocation.getArguments()[0]);
}
});
parser = new PathAnnotationRoutesParser(router);
}
@Resource
@Path("/prefix")
public static class PathAnnotatedController {
public void withoutPath() {
}
@Path("/absolutePath")
public void withAbsolutePath() {
}
@Path("relativePath")
public void withRelativePath() {
}
@Path("")
public void withEmptyPath() {
}
}
@Resource
@Path("/prefix")
public static class GetAnnotatedController {
public void withoutPath() {
}
@Get("/absolutePath")
public void withAbsolutePath() {
}
@Get("relativePath")
public void withRelativePath() {
}
@Get("")
public void withEmptyPath() {
}
}
@Resource
public static class WrongGetAnnotatedController {
@Path("/some") @Get("/other")
public void withAmbiguousDeclaration() {
}
}
@Resource
@Path("/endSlash/")
public static class EndSlashAnnotatedController {
public void withoutPath() {
}
@Path("/absolutePath")
public void withAbsolutePath() {
}
@Path("relativePath")
public void withRelativePath() {
}
@Path("")
public void withEmptyPath() {
}
}
@Resource
@Path("/endSlash/")
public static class EndSlashAnnotatedGetController {
public void withoutPath() {
}
@Get("/absolutePath")
public void withAbsolutePath() {
}
@Get("relativePath")
public void withRelativePath() {
}
@Get("")
public void withEmptyPath() {
}
}
@Resource
@Path("prefix")
public static class WrongPathAnnotatedController {
public void noSlashPath() {
}
}
@Resource
@Path({"/prefix", "/prefix2"})
public static class MoreThanOnePathAnnotatedController {
public void noSlashPath() {
}
}
@Test(expected = IllegalArgumentException.class)
public void addsAPrefixToMethodsWhenTheControllerHasMoreThanOneAnnotatedPath() throws Exception {
parser.rulesFor(new DefaultResourceClass(MoreThanOnePathAnnotatedController.class));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithRelativePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(PathAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/relativePath");
assertThat(route, canHandle(PathAnnotatedController.class, "withRelativePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithRelativePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedController.class));
Route route = getRouteMatching(routes, "/endSlash/relativePath");
assertThat(route, canHandle(EndSlashAnnotatedController.class, "withRelativePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedController.class));
Route route = getRouteMatching(routes, "/endSlash/absolutePath");
assertThat(route, canHandle(EndSlashAnnotatedController.class, "withAbsolutePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreAnnotatedWithEmptyPath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedController.class));
Route route = getRouteMatching(routes, "/endSlash/");
assertThat(route, canHandle(EndSlashAnnotatedController.class, "withEmptyPath"));
}
public void addsAPrefixToMethodsWhenTheControllerEndsWithSlashAndTheMethodAreNotAnnotated() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedController.class));
Route route = getRouteMatching(routes, "/endSlash/withoutPath");
assertThat(route, canHandle(EndSlashAnnotatedController.class, "withoutPath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(PathAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/absolutePath");
assertThat(route, canHandle(PathAnnotatedController.class, "withAbsolutePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerAndTheMethodAreAnnotatedWithEmptyPath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(PathAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix");
assertThat(route, canHandle(PathAnnotatedController.class, "withEmptyPath"));
}
@Test
public void addsAPrefixToMethodsWhenTheControllerIsAnnotatedWithPath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(PathAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/withoutPath");
assertThat(route, canHandle(PathAnnotatedController.class, "withoutPath"));
}
@Test
public void findsTheCorrectAnnotatedMethodIfThereIsNoWebMethodAnnotationPresent() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients");
assertThat(route, canHandle(ClientsController.class, "list"));
}
@Test
public void suportsTheDefaultNameForANonAnnotatedMethod() throws SecurityException,
NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/add");
assertThat(route, canHandle(ClientsController.class, "add"));
}
@Test
public void ignoresTheControllerSuffixForANonAnnotatedMethod() throws SecurityException,
NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/add");
assertThat(route, canHandle(ClientsController.class, "add"));
}
@Test
public void addsASlashWhenUserForgotIt() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/noSlash");
assertThat(route, canHandle(ClientsController.class, "noSlash"));
}
@Test
public void matchesWhenUsingAWildcard() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/move/second/child");
assertThat(route, canHandle(ClientsController.class, "move"));
}
@Test
public void dontRegisterRouteIfMethodIsNotPublic() {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/protectMe");
assertNull(route);
}
@Test
public void dontRegisterRouteIfMethodIsStatic() {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/staticMe");
assertNull(route);
}
@br.com.caelum.vraptor.Resource
public static class ClientsController {
@Path("/move/*/child")
public void move() {
}
@Path("noSlash")
public void noSlash() {
}
@Path("/clients")
public void list() {
}
@Path("/clients/remove")
@Delete
public void remove() {
}
@Path("/clients/head")
@Head
public void head() {
}
@Options("/clients/options")
public void options() {
}
@Patch("/clients/update")
public void update() {
}
public void add() {
}
@Path("/protectMe")
protected void protectMe() {
}
@Path({"/path1", "/path2"})
public void manyPaths() {
}
@Path("/staticMe")
public static void staticMe() {
}
public void toInherit() {
}
}
@br.com.caelum.vraptor.Resource
public static class NoPath {
@Path( {})
public void noPaths() {
}
}
@Test(expected=IllegalArgumentException.class)
public void shouldThrowExceptionIfPathAnnotationHasEmptyArray()
throws Exception {
parser.rulesFor(new DefaultResourceClass(NoPath.class));
}
@Test
public void shouldFindNonAnnotatedNonStaticPublicMethodWithComponentNameInVariableCamelCaseConventionAsURI()
throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/add");
assertThat(route, canHandle(ClientsController.class, "add"));
}
@Test
public void shouldFindSeveralPathsForMethodWithManyValue()
throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/path1");
assertThat(route, canHandle(ClientsController.class, "manyPaths"));
Route route2 = getRouteMatching(routes, "/path2");
assertThat(route2, canHandle(ClientsController.class, "manyPaths"));
}
@Test
public void shouldNotMatchIfAResourceHasTheWrongWebMethod() throws SecurityException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/remove");
assertThat(route.allowedMethods(), not(contains(HttpMethod.POST)));
}
@Test
public void shouldAcceptAResultWithASpecificWebMethod() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/head");
assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.HEAD)));
}
@Test
public void shouldAcceptAResultWithOptionsWebMethod() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/options");
assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.OPTIONS)));
}
@Test
public void shouldAcceptAResultWithPatchWebMethod() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(ClientsController.class));
Route route = getRouteMatching(routes, "/clients/update");
assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.PATCH)));
}
static class NiceClients extends ClientsController {
@Override
public void add() {
super.add();
}
}
@Test
public void findsInheritedMethodsWithDefaultNames() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(NiceClients.class));
Route route = getRouteMatching(routes, "/niceClients/toInherit");
assertTrue(route.canHandle(NiceClients.class, ClientsController.class.getDeclaredMethod("toInherit")));
}
@Test
public void supportMethodOverriding() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(NiceClients.class));
Route route = getRouteMatching(routes, "/niceClients/add");
assertThat(route, canHandle(NiceClients.class, "add"));
}
@Post
static class AnnotatedController {
public void test() {}
@Get
public void overridden() {}
}
@Test
public void supportTypeHttpMethodAnnotation() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(AnnotatedController.class));
Route route = getRouteMatching(routes, "/annotated/test");
assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.POST)));
}
@Test
public void supportOverrideTypeHttpMethodAnnotation() throws SecurityException, NoSuchMethodException {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(AnnotatedController.class));
Route route = getRouteMatching(routes, "/annotated/overridden");
assertThat(route.allowedMethods(), is(EnumSet.of(HttpMethod.GET)));
}
private Route getRouteMatching(List<Route> routes, String uri) {
for (Route route : routes) {
if (route.canHandle(uri)) {
return route;
}
}
return null;
}
private Matcher<Route> canHandle(final Class<?> type, final String method) {
return new TypeSafeMatcher<Route>() {
@Override
protected void describeMismatchSafely(Route item, Description mismatchDescription) {
}
@Override
protected boolean matchesSafely(Route item) {
try {
return item.canHandle(type, type.getDeclaredMethod(method));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void describeTo(Description description) {
description.appendText("a route which can handle ").appendValue(type).appendText(".").appendValue(method);
}
};
}
@Test
public void addsAPrefixToMethodsWhenTheGetControllerAndTheMethodAreAnnotatedWithRelativePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(GetAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/relativePath");
assertThat(route, canHandle(GetAnnotatedController.class, "withRelativePath"));
}
@Test
public void priorityForGetAnnotationShouldBeDefault() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(GetAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/relativePath");
assertThat(route.getPriority(), is(Path.DEFAULT));
}
@Test
public void addsAPrefixToMethodsWhenTheGetControllerEndsWithSlashAndTheMethodAreAnnotatedWithRelativePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedGetController.class));
Route route = getRouteMatching(routes, "/endSlash/relativePath");
assertThat(route, canHandle(EndSlashAnnotatedGetController.class, "withRelativePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheGetControllerEndsWithSlashAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(EndSlashAnnotatedGetController.class));
Route route = getRouteMatching(routes, "/endSlash/absolutePath");
assertThat(route, canHandle(EndSlashAnnotatedGetController.class, "withAbsolutePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheGetControllerAndTheMethodAreAnnotatedWithAbsolutePath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(GetAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/absolutePath");
assertThat(route, canHandle(GetAnnotatedController.class, "withAbsolutePath"));
}
@Test
public void addsAPrefixToMethodsWhenTheGetControllerIsAnnotatedWithPath() throws Exception {
List<Route> routes = parser.rulesFor(new DefaultResourceClass(GetAnnotatedController.class));
Route route = getRouteMatching(routes, "/prefix/withoutPath");
assertThat(route, canHandle(GetAnnotatedController.class, "withoutPath"));
}
@Test(expected=IllegalArgumentException.class)
public void throwsExceptionWhenTheGetControllerHasAmbiguousDeclaration() throws Exception {
parser.rulesFor(new DefaultResourceClass(WrongGetAnnotatedController.class));
}
}