/***
* 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.validator;
import static br.com.caelum.vraptor.controller.DefaultControllerMethod.instanceFor;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import java.lang.reflect.Method;
import java.util.Locale;
import javax.validation.MessageInterpolator;
import javax.validation.ValidatorFactory;
import javax.validation.constraints.Min;
import org.hibernate.validator.constraints.Email;
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockitoAnnotations;
import br.com.caelum.vraptor.controller.ControllerMethod;
import br.com.caelum.vraptor.controller.DefaultControllerInstance;
import br.com.caelum.vraptor.core.MethodInfo;
import br.com.caelum.vraptor.events.MethodReady;
import br.com.caelum.vraptor.http.ParanamerNameProvider;
import br.com.caelum.vraptor.util.test.MockInstanceImpl;
import br.com.caelum.vraptor.util.test.MockValidator;
import br.com.caelum.vraptor.validator.beanvalidation.MessageInterpolatorFactory;
import br.com.caelum.vraptor.validator.beanvalidation.MethodValidator;
/**
* Test method validator feature.
*
* @author Otávio Scherer Garcia
* @author Rodrigo Turini
* @since 3.5
*/
public class MethodValidatorTest {
private Validator validator;
private ValidatorFactory validatorFactory;
private MessageInterpolator interpolator;
private ControllerMethod withConstraint;
private ControllerMethod withoutConstraint;
private ControllerMethod withoutConstraintAndDomainObject;
private DefaultControllerInstance instance;
private MethodInfo methodInfo = new MethodInfo(new ParanamerNameProvider());
@Before
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
Locale.setDefault(Locale.ENGLISH);
validatorFactory = javax.validation.Validation.buildDefaultValidatorFactory();
interpolator = new MessageInterpolatorFactory(validatorFactory).getInstance();
validator = new MockValidator();
withConstraint = instanceFor(MyController.class, getMethod("withConstraint",String.class));
withoutConstraint = instanceFor(MyController.class, getMethod("withoutConstraint",String.class));
withoutConstraintAndDomainObject = instanceFor(MyController.class, getMethod("withoutConstraintAndDomainObject",Example.class));
instance = new DefaultControllerInstance(new MyController());
}
private Method getMethod(String methodName,Class<?> parameterClass) throws NoSuchMethodException {
return MyController.class.getMethod(methodName, parameterClass);
}
@Test
public void shouldAcceptIfMethodHasConstraint() {
methodInfo.setControllerMethod(withConstraint);
DefaultControllerInstance controller = spy(instance);
getMethodValidator().validate(new MethodReady(withConstraint), controller, methodInfo, validator);
verify(controller).getController();
}
@Test
public void shouldNotAcceptIfMethodHasConstraint() {
DefaultControllerInstance controller = spy(instance);
getMethodValidator().validate(new MethodReady(withoutConstraint), controller, methodInfo, validator);
verify(controller, never()).getController();
}
@Test
public void shouldNotAcceptIfMethodDoesNotHaveConstraintAndHasDomainObjectParameter() {
DefaultControllerInstance controller = spy(instance);
getMethodValidator().validate(new MethodReady(withoutConstraintAndDomainObject), controller, methodInfo, validator);
verify(controller, never()).getController();
}
@Test
public void shouldValidateMethodWithConstraint() throws Exception {
methodInfo.setControllerMethod(withConstraint);
methodInfo.setParameter(0, "a");
Message[] expected = { new SimpleMessage("email", "deve ser maior ou igual a 10"),
new SimpleMessage("email", "Não é um endereço de e-mail") };
getMethodValidator().validate(new MethodReady(withConstraint), instance, methodInfo, validator);
assertThat(validator.getErrors(), hasSize(2));
assertThat(validator.getErrors(), containsInAnyOrder(expected));
}
private MethodValidator getMethodValidator() {
return new MethodValidator(new MockInstanceImpl<Locale>(new Locale("pt", "br")), interpolator, validatorFactory.getValidator());
}
public class Example {
private int number;
private String name;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class MyController {
public void withConstraint(@Min(10) @Email String email) {
}
public void withoutConstraint(String foo) {
}
public void withoutConstraintAndDomainObject(Example example) {
}
}
}